import random
# 1、写函数,将传入的列表或元祖对象的奇数位索引对应的元素
"""def hanshu(obj):
#        0 1 2 3 4 5 6 7 8 9  10 11
#        2 4 6
    list1 = []
    for i in range(len(obj)):# len(list1)
        if i%2!=0:
            list1.append(obj[i])
    return list1
list1=[1, 2, 3, 4, 5, 6, 7, 78, 8, 9, 9, 9, 98, 7, 6, 6, 5, 5, 4, 4]
print(hanshu(list1))
"""
# 2、写函数,判断用户传入的对象(string,list,tuple)长度是否大于5
"""def islen(obj):
    if len(obj) >5:
        print("大于5")
    elif len(obj) == 5:
        print("等于5")
    else:
        print("小于5")
islen("asdasdasd1")
islen((1,2,3,4,5,6))
islen([1,2,3,4,5,6,7])
"""

# 3、写函数,计算传入的string中,数字,字母,空格以及其它内容的个数,并返回结果
"""str2 = "asd 123 !@#"
def count_type(string): # string是形式参数，形参
    count_num = 0 # 计算数字的个数
    count_zimu = 0 # 计算字母的个数
    count_space = 0 # 计算空格的个数
    count_other = 0 # 计算其他字符的个数
    for i in string:
        if i in "0123456789":
            print("%s是数字对象"%i)
            count_num +=1 # 如果是数字，就+1
        elif (i >="a" and i <="z") or (i >="A" and i<="Z"):
            print("%s是字母对象"%i)
            count_zimu +=1
        elif i == " ":
            print("%s是空格对象"%i)
            count_space +=1
        else:
            count_other+=1
            print("%s是其他内容"%i)
    return f"数字的个数是：{count_num}，字母的个数是：{count_zimu}，空格的个数是：{count_space},其他内容的个数是：{count_other}"
count_type(str2) # str2 叫做实际参数，实参"""

# 4、写函数,接收两个数字参数,返回较大的那个数字
"""def max_num(int1,int2):
    if int1 > int2:
        return int1
    elif int1 == int2:
        print("两个数字相等")
    else:
        return int2
int1 = 50
int2 = 60
print(max_num(int1, int2))"""
# 5、编写一个函数cacluate, 可以接收任意多个数,返回的是一个元组.
def cacluate(*args):
    return args


# print(cacluate(1, 2, 3123, 123, "asd", [1, 123], {1, 23, 2}, {"name": "suki"}))
# 6、编写一个函数, 接收字符串参数, 返回一个元组,元组的第一个值为大写字母的个数, 第二个值为小写字母个数.
def string_count(obj:str):
    d = 0 # 计算大写的个数
    x = 0 # 计算小写的个数
    for i in obj:
        if i >="a" and i <="z":
            x +=1 # 如果在这个范围，小写的个数+1
        elif i >="A" and i<="Z":
            d +=1 # 如果在这个范围，大写的个数+1
    return x,d # 返回的是一个元组
# print(string_count("asdasdasAAD"))

# 7、编写函数, 接收一个列表(包含30个1~100之间的随机整形数)和一个整形数k, 返回一个新列表.
# 函数需求:
# 将列表下标k之前对应(不包含k)的元素逆序;
# 将下标k及之后的元素逆序;
import random
def list_obj(list1,k):
    """
    :param list1: 接收1~100之间的随机整型数
    :param k:  整型数K
    :return: list
    """
    count = 0 # 计数是不是每一个都在1~100之间
    if len(list1) == 30: # 如果说列表的长度等于30了
        for i in list1:  # 循环列表中的每一个元素
            if i >=1 and i <= 100: # 如果这个元素大于等于1并且说小于等于100
                count +=1 # 计数 ，加到一起
        if count == 30:  # 如果每一个数字都是大于等于1并且小于等于100
            r_list = list1[:k][::-1] # 按照题目要求做分割
            x_list = list1[k:][::-1] # 按照题目要求做分割
            return r_list + x_list # 最后合并列表返回
        else:
            return "列表里面有超过100或小于1的整型数字"
    else: # 如果列表长度不是30， 那就没必要走后面的判断了
        return "长度不足30" # 直接返回不足30就可以了
ran_num_list = [random.randint(1,100) for i in range(30)] # 随机数的列表，有30个
# print(ran_num_list) # [44, 50, 61, 94, 87, 95, 90, 91, 51, 22, 95, 35, 97, 94, 5, 2, 95, 52, 59, 80, 39, 89, 40, 93, 25, 43, 63, 96, 47, 89]
"""
list1 = [44, 50, 61, 94, 87, 95, 90, 91, 51, 22, 95, 35, 97, 94, 5, 2, 95, 52, 59, 80, 39, 89, 40, 93, 25, 43, 63, 96, 47, 89]
list1[:k][::-1]  [44, 50, 61, 94, 87][::-1]              [87,94,61,50,44]
list1[k:][::-1]  [95, 90, 91, 51, 22, 95, 35, 97, 94, 5, 2, 95, 52, 59, 80, 39, 89, 40, 93, 25, 43, 63, 96, 47, 89][::-1]  [89,47,96,63,43,25,93,40,89,39,80,59,52,95,2,5,94,97,35,95,22,51,91,90,95]
[87,94,61,50,44] + [89,47,96,63,43,25,93,40,89,39,80,59,52,95,2,5,94,97,35,95,22,51,91,90,95]
"""
# print(list_obj(ran_num_list, 5)) # [87, 94, 61, 50, 44, 89, 47, 96, 63, 43, 25, 93, 40, 89, 39, 80, 59, 52, 95, 2, 5, 94, 97, 35, 95, 22, 51, 91, 90, 95]


# 8、编写函数，从键盘输入参数x和n，计算并显示形如x+xx +xxx + xxxx + xxxxx+xxx…xxx+ 的表达式前n项的值
def sum_xn(x,n):
    """
    :param x: 基础数字，每次循环+一位
    1
    11  1*10+1
    111  11*10+1
    1111 111*10+1
    11111  1111*10+1
    :param n: 控制循环的次数
    :return:
    """
    g = x # 把个位数固定住
    sum = 0 # 收集所有结果的和
    for i in range(n):
        """
        x = 1
        n = 5
        第一次循环：
        0+=1   sum就是1了
        1*10+1 = 11
        sum +=11
        """
        sum += x # 每一次让他去收集x变化的结果和
        if i == n-1: # 如果说i循环变量等于n-1的最后一次循环
            print(f"{x}={sum}",end="\n") # 那么就打印表达式为， 33333 = 37035
        else:
            print(f"{x}",end='+') # 如果不是i最后一次循环，那么就打印相加，3+33+333+3333+
        x = x * 10 + g # 每一次让他的结果都变为：x*10+g
    return sum
s = 3
n = 5
# sum_xn(s, n) # 3+33+333+3333+33333
# 9、写函数,函数接收的4个参数分别是:姓名,性别(默认为男),年龄,地址
def person_info(name,age,address,sex="男"):
    return f"姓名为：{name}，年龄是：{age}，地址为：{address}，性别为：{sex}"

# 10、写函数,接收n个数字,返回这些数字的和(动态传参)
def sum_n(*n):
    sum = 0
    for i in n:
        sum+=i
    return sum

# 11、在实参中传入多个可迭代对象(要有string,list,tuple,set,dict),将每个对象的每个元素都加到args或kwargs里
def iter_obj(*args,**kwargs):
    """
    :param args: 不定长参数
    :param kwargs:  关键字不定长参数
    :return:
    """
    print(args)
    print(kwargs)


# 12、写函数,把传过来的列表中的每一个元素都用"_"拼接,并返回
def _list(list1):
    str1 = ""
    for i in list1:
        i = str(i)+"_"
        str1 +=i
    return str1[:len(str1)-1] # 1_2_3_，最后一个_不要了
# print(_list([1, 2, 3])) #
# 13、写函数,传入一个数字,返回这个数的阶乘。示例：1x2x3....
def x_n(n):
    num = 1
    for i in range(1,n+1):
        num = num*i
    return num
# # 1x2x3
# print(x_n(3))

# 14、写函数,返回一个扑克牌列表,里面有52项,每一项都是一个tuple
def puke():
    list_2 = []
    for key in ['梅花','方块','红桃','黑桃']:
        for value in (2,3,4,5,6,7,8,9,10,'J','Q','K','A'):
            list_2.append((key,value))
    return list_2
# print(puke())
# 15、编写函数，求1+2+3+…N的和
def sum_n_1(n):
    sum = 0
    for i in range(1,n+1):
        sum+=i
    return sum
# 16、编写一个函数，求多个数中的最大值
def max_num(*num):
    max_n = num[-1] # 随便找了一个数，用它来比对
    for i in num:
        if i > max_n:
            max_n = i
    return max_n

# 31232321
# print(max_num(123, 123, 123, 123, 123, 12, 312, 31232321, 2131231, 1231232, 123))
# 17、编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
def new_str(str_obj):
    n_str = ""
    for i in str_obj:
        if (i >="a" and i <='z') or (i >="A" and i <='Z'):
            n_str+=i
    return f"新的字符串为：{n_str}"
# print(new_str("asda123asda123!@##$$%ASASDQ")) # asdaasdaASASDQ

# 18、写一个函数，求多个数的平均值
def avg_num(*n):
    print(sum(n) / len(n))

# 19、写一个自己的len函数，统计指定序列中元素的个数
def len_num(x):
    count = 0
    for i in x:
        count+=1
    return count

# 20、找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表
def new_list(x):
    list1 = [] # 创建了一个空列表
    for i in range(len(x)): # 根据原来的序列索引进行遍历
        if i%2!=0: # 如果这个索引取余2不等于0 ，那就说明是一个奇数
            list1.append(x[i]) # 把这个奇数位的索引值加到新列表里面去
    return list1 # 返回这个新列表
# print(new_list([1, 2, 3, 4, 5])) # 2 4
# 21、水仙花数：个位、十位、百位的立方加在一起等于数的本身
def shui():
    for i in range(100,1000): # 111
        if int(str(i)[0])**3 + int(str(i)[1])**3 + int(str(i)[2])**3 == i:
            print(i,end="\t") # tab键
# 153	370	371	407
"""
3*3*3 + 5*5*5 + 1
"""
# 22、 定义函数，有一个形参，传入的是列表，数组大小不超过 100个，
# 数组中的每个元素值不允许超过 100，但是可以等于100，
# 如果列表大小超过了100个截取到第100个为止，要求返回的列表格式：
# 删除所有重复元素，使得每个元素只出现一次
# 按照数字的大小，由高到低排序返回
def re_list(list1):
    list1 = list1[:100]
    list2 = [] # 收集所有的结果
    for i in list1: # 遍历每一个元素
        if i <=100: # 如果某一个元素小于等于100
            list2.append(i) # 把他加进去，符合条件
                # count+=1
    list2 = list(set(list2))# 去掉重复的元素，先转成集合，再转成列表
    list2.sort(reverse=True) # 列表倒序返回
    return list2
import random
# print(re_list([99, 10, 20, 30, 40, 50, 109,119]))
ran_num = [random.randint(1,101) for j in range(111)]
# print(len(re_list(ran_num)))
# 23、定义函数 getLength，打印用户传入的容器类型和数据长度
def getLength(cn):
    if isinstance(cn,dict): # cn为带判断的对象，dict为判断他是不是这个类型
        return f"传入的类型是字典，长度为：{len(cn)}"
    elif isinstance(cn,list):
        return f"传入的类型是列表，长度为：{len(cn)}"
    elif isinstance(cn,tuple):
        return f"传入的类型是元组，长度为：{len(cn)}"
    elif isinstance(cn,str):
        return f"传入的类型是字符串，长度为：{len(cn)}"
    elif isinstance(cn,int):
        return f"传入的类型是整数类型，长度为：{len(str(cn))}" # 整数不能用int，转成字符串你再去算长度
    elif isinstance(cn,set):
        return f"传入的类型是集合，长度为：{len(cn)}"
# print(getLength({"name": "suki"}))
# print(getLength([1, 2, 3, 4, 5]))
# print(getLength((11, 223, 44, 55)))
# print(getLength("asdasdqasd"))
# print(getLength(1111))
# print(getLength({1, 2, 3, 123, "asda"}))


# 24、定义函数 generateNum( )
def generateNum():
    return 1
# 25、定义函数 moreThan(num)，判断输入的数字是否大于1500
def moreThan(num):
    if num > 1500:
        return "大于"
    elif num == 1500:
        return "等于"
    else:
        return "小于"
# 26、定义函数，有两个形参，第一个形参到第二个形参的范围，所有平方数之和
def avgNum(a,b):
    sum = 0
    for i in range(a,b+1):
        sum +=i**2
    return sum
# print(avgNum(1,5)) # 1*1+2*2+3*3+4*4+5*5
# 27、写函数，检查传入字典的每一个value长度，如果大于2，那么仅保留前两个长度的内容， 并将新内容返回给调用者
def dict_value(dict1:dict):
    for key,value in dict1.items():
        if len(value) > 2:
            dict1[key] = value[:2]
    return dict1
# print(dict_value({"name": "123", "address": "沈阳市"}))
#  28、写函数，判断用户传入的对象（字符串、列表、元组）的元素是否为空
def isNone(n):
    if isinstance(n,str):
        if n: # 判断的是布尔值，直接这样去判断会返回True
            return f"传入的是字符串对象：{n}，不为空" # 为True则执行这句话
        else:
            return f"传入的是字符串对象：{n}，为空" # 反之返回这句话
    elif isinstance(n,list):
        if n: # 判断的是布尔值，直接这样去判断会返回True
            return f"传入的是列表对象：{n}，不为空" # 为True则执行这句话
        else:
            return f"传入的是列表对象：{n}，为空" # 反之返回这句话
    elif isinstance(n,tuple):
        if n: # 判断的是布尔值，直接这样去判断会返回True
            return f"传入的是元组对象：{n}，不为空" # 为True则执行这句话
        else:
            return f"传入的是元组对象：{n}，为空" # 反之返回这句话
"""print(isNone(""))
print(isNone("1"))
print(isNone([]))
print(isNone([1]))
print(isNone(()))
print(isNone((1,)))"""
# 29、编写自定义函数，完成一个简单的减法运算函数
def jisuanqi(a,b):
    return a-b
# 30、编写自定义函数，可以输出自己的名字即可。
def get_name(name):
    return f"我的名字是：{name}"
# 31、编写自定义函数：剪刀石头布
# 游戏开始，初始状态下用户和电脑都有 100 分，赢一局+10 分，输一局-10 分。
# 当用户为 0 分时，游戏结束，提示游戏结束，比赛输了
# 当用户为 200 分时，游戏结束，提示游戏结束，赢得比赛、每轮比赛都输出当前的分数
# 1 代表剪刀 2 代表石头 3 代表布
def paly_():
    user = 100
    compter = 100
    while True:
        com = random.randint(1,3) # 1 代表剪刀 2 代表石头 3 代表布
        if user == 0:
            print(f"电脑玩家还有：{compter}分数！")
            print(f"你还有：{user}分数！")
            print("分数0，游戏结束！你败了")
            break
        if compter == 0:
            print(f"电脑玩家还有：{compter}分数！")
            print(f"你还有：{user}分数！")
            print("分数0，游戏结束！你胜了")
            break
        y = int(input("请你输入剪刀石头布（1 代表剪刀 2 代表石头 3 代表布）："))
        if com == 1 and y == 1:
            print("平局！")
            print(f"电脑玩家还有：{compter}分数！")
            print(f"你还有：{user}分数！")
        elif com == 1 and y == 2:
            print("这局你赢了！电脑玩家败！")
            user+=10
            compter-=10
            print(f"电脑玩家还有：{compter}分数！")
            print(f"你还有：{user}分数！")
        elif com == 1 and y ==3:
            print("这局你输了，电脑玩家获胜！")
            user -= 10
            compter += 10
            print(f"电脑玩家还有：{compter}分数！")
            print(f"你还有：{user}分数！")
        elif com == 2 and y ==1:
            print("这局你输了，电脑玩家获胜！")
            user -= 10
            compter += 10
            print(f"电脑玩家还有：{compter}分数！")
            print(f"你还有：{user}分数！")
        elif com == 2 and y == 2:
            print("平局！")
            print(f"电脑玩家还有：{compter}分数！")
            print(f"你还有：{user}分数！")
        elif com == 2 and y ==3:
            print("这局你赢了！电脑玩家败！")
            user += 10
            compter -= 10
            print(f"电脑玩家还有：{compter}分数！")
            print(f"你还有：{user}分数！")
        elif com == 3 and y == 1:
            print("这局你赢了！电脑玩家败！")
            user += 10
            compter -= 10
            print(f"电脑玩家还有：{compter}分数！")
            print(f"你还有：{user}分数！")
        elif com ==3 and y==2:
            print("这局你输了，电脑玩家获胜！")
            user -= 10
            compter += 10
            print(f"电脑玩家还有：{compter}分数！")
            print(f"你还有：{user}分数！")
        elif com == 3 and y==3:
            print("平局！")
            print(f"电脑玩家还有：{compter}分数！")
            print(f"你还有：{user}分数！")
# 32、编写一个函数，接受一个字符串作为参数，并返回该字符串的逆序字符串
def str1(str_obj):
    return str_obj[::-1]

# 33、编写一个函数，接受一个数字列表作为参数，并返回其中所有偶数的列表
def get_list(list1):
    list2 = []
    for i in list1:
        if i%2==0:
            list2.append(i)
    return list2

# 34、编写一个函数，接受一个字符串列表作为参数，并返回其中最长的字符串。
def str_list(list1):
    max_str = list1[0]
    for i in list1:
        if len(i) > len(max_str):
            max_str = i
    return f"最长的字符串是：{max_str}，长度为：{len(max_str)}"

# print(str_list(['123', 'asdasdas', '123asd', 'asdas!!@#']))

# 35、编写一个函数，接受一个数字列表作为参数，并返回其中所有数字的平方的总和
def num_list(numl):
    sum = 0
    for i in numl:
        sum += i**2
    return sum
# 36、编写一个函数，接受一个字符串作为参数，并返回其中所有单词的首字母的大写形式
def Cstr(str_obj:str): # 单词中间有空格
    str_list = str_obj.split(" ") # 按照空格分割字符串
    new_str = "" # 用于接收所有的字符串结果集
    for i in str_list: # 遍历字符串列表
        new_str+=i.capitalize() + " " # 用新的字符串结果集，接收每一个处理好的字符串的大写+空格
    return new_str # 返回新的字符串内容
# print(Cstr("asd asd qwe poi asd qwe test jmeter postman"))

# 37、编写一个函数，接受两个列表作为参数，并返回两个列表的交集
# 举例：

# 返回：[454]
def f_list(list1,list2):
    if len(list1) == len(list2):
        for i in range(len(list1)):
            """
            因为两个列表的长度都是一样的，所以根据索引去遍历访问每一个对象
            """
            if list2[i] in list1:
                """
                如果说某一个列表2中的值，在列表1里面
                """
                print(list2[i]) # 那就说明找到了交集
list1 = [100,200,300,454]
list2 = [454,789,125,46]
f_list(list1,list2)
#  38、定义一个学生注册函数enroll()，打印学生姓名，性别，年龄，城市
def enroll(name,sex,age,address):
    print(name,sex,age,address)

